home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume29 / zsh2.2 / part16 < prev    next >
Encoding:
Text File  |  1992-05-13  |  49.0 KB  |  2,005 lines
  1. Newsgroups: comp.sources.misc
  2. From: pfalstad@phoenix.Princeton.EDU (Paul Falstad)
  3. Subject:  v29i112:  zsh2.2 - The Z shell, Part16/17
  4. Message-ID: <1992May13.161048.11193@sparky.imd.sterling.com>
  5. X-Md4-Signature: 0c3b87c59885f3fa25b6297a6522572c
  6. Date: Wed, 13 May 1992 16:10:48 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: pfalstad@phoenix.Princeton.EDU (Paul Falstad)
  10. Posting-number: Volume 29, Issue 112
  11. Archive-name: zsh2.2/part16
  12. Environment: BSD
  13. Supersedes: zsh2.1: Volume 24, Issue 1-19
  14.  
  15. #!/bin/sh
  16. # this is aa.16 (part 16 of zsh2.2)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file zsh2.2/src/params.pro continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 16; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping zsh2.2/src/params.pro'
  34. else
  35. echo 'x - continuing file zsh2.2/src/params.pro'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'zsh2.2/src/params.pro' &&
  37. Xvoid lithistsizesetfn DCLPROTO((Param pm,long v));
  38. Xlong lithistsizegetfn DCLPROTO((Param pm));
  39. Xvoid mailchecksetfn DCLPROTO((Param pm,long x));
  40. Xvoid pathasetfn DCLPROTO((Param pm,char **x));
  41. Xchar **pathagetfn DCLPROTO((Param pm));
  42. Xlong errnogetfn DCLPROTO((Param pm));
  43. Xchar *dashgetfn DCLPROTO((Param pm));
  44. Xvoid histcharssetfn DCLPROTO((Param pm,char *x));
  45. Xchar *histcharsgetfn DCLPROTO((Param pm));
  46. Xchar *homegetfn DCLPROTO((Param pm));
  47. Xvoid homesetfn DCLPROTO((Param pm,char *x));
  48. Xchar *wordcharsgetfn DCLPROTO((Param pm));
  49. Xvoid wordcharssetfn DCLPROTO((Param pm,char *x));
  50. Xchar *underscoregetfn DCLPROTO((Param pm));
  51. Xchar *termgetfn DCLPROTO((Param pm));
  52. Xvoid termsetfn DCLPROTO((Param pm,char *x));
  53. Xvoid setparams DCLPROTO((void));
  54. Xchar *mkenvstr DCLPROTO((char *x,char *y));
  55. Xvoid arrfixenv DCLPROTO((char *s,char **t));
  56. Xchar *replenv DCLPROTO((char *e,char *value));
  57. Xchar *addenv DCLPROTO((char *name,char *value));
  58. Xvoid delenv DCLPROTO((char *x));
  59. Xvoid convbase DCLPROTO((char *s,long v,int base));
  60. SHAR_EOF
  61. echo 'File zsh2.2/src/params.pro is complete' &&
  62. chmod 0644 zsh2.2/src/params.pro ||
  63. echo 'restore of zsh2.2/src/params.pro failed'
  64. Wc_c="`wc -c < 'zsh2.2/src/params.pro'`"
  65. test 3478 -eq "$Wc_c" ||
  66.     echo 'zsh2.2/src/params.pro: original size 3478, current size' "$Wc_c"
  67. rm -f _shar_wnt_.tmp
  68. fi
  69. # ============= zsh2.2/src/subst.pro ==============
  70. if test -f 'zsh2.2/src/subst.pro' -a X"$1" != X"-c"; then
  71.     echo 'x - skipping zsh2.2/src/subst.pro (File already exists)'
  72.     rm -f _shar_wnt_.tmp
  73. else
  74. > _shar_wnt_.tmp
  75. echo 'x - extracting zsh2.2/src/subst.pro (Text)'
  76. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/subst.pro' &&
  77. Xvoid prefork DCLPROTO((Lklist list));
  78. Xvoid postfork DCLPROTO((Lklist list,int doglob));
  79. Xvoid singsub DCLPROTO((char **s));
  80. Xvptr nstrdup DCLPROTO((vptr s));
  81. Xchar *dynread DCLPROTO((int stop));
  82. Xint filesub DCLPROTO((char **namptr));
  83. Xchar *gethome DCLPROTO((char *user,int len));
  84. Xvoid commsubst DCLPROTO((Lklist l,Lknode n,char *str3,char *str,int qt));
  85. Xvoid paramsubst DCLPROTO((Lklist l,Lknode n,char *aptr,char *bptr,int qt));
  86. Xvoid arithsubst DCLPROTO((vptr *aptr,char **bptr));
  87. Xvoid modify DCLPROTO((char **str,char **ptr));
  88. Xchar *dstackent DCLPROTO((int val));
  89. Xstruct alias *mkanode DCLPROTO((char *txt,int cmflag));
  90. SHAR_EOF
  91. chmod 0644 zsh2.2/src/subst.pro ||
  92. echo 'restore of zsh2.2/src/subst.pro failed'
  93. Wc_c="`wc -c < 'zsh2.2/src/subst.pro'`"
  94. test 619 -eq "$Wc_c" ||
  95.     echo 'zsh2.2/src/subst.pro: original size 619, current size' "$Wc_c"
  96. rm -f _shar_wnt_.tmp
  97. fi
  98. # ============= zsh2.2/src/table.pro ==============
  99. if test -f 'zsh2.2/src/table.pro' -a X"$1" != X"-c"; then
  100.     echo 'x - skipping zsh2.2/src/table.pro (File already exists)'
  101.     rm -f _shar_wnt_.tmp
  102. else
  103. > _shar_wnt_.tmp
  104. echo 'x - extracting zsh2.2/src/table.pro (Text)'
  105. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/table.pro' &&
  106. XLklist newlist DCLPROTO((void));
  107. XHashtab newhtable DCLPROTO((int size));
  108. Xint hasher DCLPROTO((char *s));
  109. Xvoid Addhnode DCLPROTO((char *nam,vptr dat,Hashtab ht,FFunc freefunc,int canfree));
  110. Xvoid addhcmdnode DCLPROTO((char *nam,char **pnam));
  111. Xvoid expandhtab DCLPROTO((Hashtab ht));
  112. Xvptr gethnode DCLPROTO((char *nam,Hashtab ht));
  113. Xvoid freehtab DCLPROTO((Hashtab ht,FFunc freefunc));
  114. Xvptr remhnode DCLPROTO((char *nam,Hashtab ht));
  115. Xvoid insnode DCLPROTO((Lklist list,Lknode llast,vptr dat));
  116. Xvoid addnodeinorder DCLPROTO((Lklist x, char *dat));
  117. Xvptr remnode DCLPROTO((Lklist list,Lknode nd));
  118. Xvptr uremnode DCLPROTO((Lklist list,Lknode nd));
  119. Xvoid chuck DCLPROTO((char *str));
  120. Xvptr getnode DCLPROTO((Lklist list));
  121. Xvptr ugetnode DCLPROTO((Lklist list));
  122. Xvoid freetable DCLPROTO((Lklist tab,FFunc freefunc));
  123. Xchar *ztrstr DCLPROTO((char *s,char *t));
  124. Xvoid inslist DCLPROTO((Lklist l,Lknode where,Lklist x));
  125. Xint countnodes DCLPROTO((Lklist x));
  126. SHAR_EOF
  127. chmod 0644 zsh2.2/src/table.pro ||
  128. echo 'restore of zsh2.2/src/table.pro failed'
  129. Wc_c="`wc -c < 'zsh2.2/src/table.pro'`"
  130. test 941 -eq "$Wc_c" ||
  131.     echo 'zsh2.2/src/table.pro: original size 941, current size' "$Wc_c"
  132. rm -f _shar_wnt_.tmp
  133. fi
  134. # ============= zsh2.2/src/text.pro ==============
  135. if test -f 'zsh2.2/src/text.pro' -a X"$1" != X"-c"; then
  136.     echo 'x - skipping zsh2.2/src/text.pro (File already exists)'
  137.     rm -f _shar_wnt_.tmp
  138. else
  139. > _shar_wnt_.tmp
  140. echo 'x - extracting zsh2.2/src/text.pro (Text)'
  141. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/text.pro' &&
  142. Xvoid taddchr DCLPROTO((int c));
  143. Xvoid taddstr DCLPROTO((char *s));
  144. Xvoid taddint DCLPROTO((int x));
  145. Xvoid taddnl DCLPROTO((void));
  146. Xchar *getpermtext DCLPROTO((struct node *n));
  147. Xchar *getjobtext DCLPROTO((struct node *n));
  148. Xvoid gettext2 DCLPROTO((struct node *n));
  149. Xvoid getsimptext DCLPROTO((Cmd cmd));
  150. Xvoid getredirs DCLPROTO((Cmd cmd));
  151. Xvoid taddlist DCLPROTO((Lklist l));
  152. SHAR_EOF
  153. chmod 0644 zsh2.2/src/text.pro ||
  154. echo 'restore of zsh2.2/src/text.pro failed'
  155. Wc_c="`wc -c < 'zsh2.2/src/text.pro'`"
  156. test 371 -eq "$Wc_c" ||
  157.     echo 'zsh2.2/src/text.pro: original size 371, current size' "$Wc_c"
  158. rm -f _shar_wnt_.tmp
  159. fi
  160. # ============= zsh2.2/src/utils.pro ==============
  161. if test -f 'zsh2.2/src/utils.pro' -a X"$1" != X"-c"; then
  162.     echo 'x - skipping zsh2.2/src/utils.pro (File already exists)'
  163.     rm -f _shar_wnt_.tmp
  164. else
  165. > _shar_wnt_.tmp
  166. echo 'x - extracting zsh2.2/src/utils.pro (Text)'
  167. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/utils.pro' &&
  168. Xint source DCLPROTO((char *s));
  169. Xvoid sourcehome DCLPROTO((char *s));
  170. Xvoid zerrnam DCLPROTO((char *cmd, char *fmt, char *str,int num));
  171. Xvoid zerr DCLPROTO((char *fmt, char *str,int num));
  172. Xvoid niceputc DCLPROTO((int c,FILE *f));
  173. Xvoid intr DCLPROTO((void));
  174. Xvoid noholdintr DCLPROTO((void));
  175. Xvoid holdintr DCLPROTO((void));
  176. Xchar *fgetline DCLPROTO((char *buf,int len,FILE *in));
  177. Xchar *findpwd DCLPROTO((char *s));
  178. Xchar *fixpwd DCLPROTO((char *s));
  179. Xint ispwd DCLPROTO((char *s));
  180. Xchar *xsymlink DCLPROTO((char *s));
  181. Xchar **slashsplit DCLPROTO((char *s));
  182. Xint islink DCLPROTO((char *s));
  183. Xint xsymlinks DCLPROTO((char *s,int flag));
  184. Xvoid fprintdir DCLPROTO((char *s, FILE *f));
  185. Xvoid printdir DCLPROTO((char *s));
  186. Xvoid printdircr DCLPROTO((char *s));
  187. Xint finddir DCLPROTO((char *s));
  188. Xvoid adduserdir DCLPROTO((char *s,char *t));
  189. Xint dircmp DCLPROTO((char *s,char *t));
  190. Xint ddifftime DCLPROTO((time_t t1,time_t t2));
  191. Xvoid scanjobs DCLPROTO((void));
  192. Xvoid preprompt DCLPROTO((void));
  193. Xint arrlen DCLPROTO((char **s));
  194. Xvoid checkmailpath DCLPROTO((char **s));
  195. Xvoid saveoldfuncs DCLPROTO((char *x,Cmdnam y));
  196. Xvoid newcmdnamtab DCLPROTO((void));
  197. Xvoid freecmdnam DCLPROTO((vptr a));
  198. Xvoid freecompctl DCLPROTO((vptr a));
  199. Xvoid freestr DCLPROTO((vptr a));
  200. Xvoid freeanode DCLPROTO((vptr a));
  201. Xvoid freepm DCLPROTO((vptr a));
  202. Xvoid restoretty DCLPROTO((void));
  203. Xvoid gettyinfo DCLPROTO((struct ttyinfo *ti));
  204. Xvoid settyinfo DCLPROTO((struct ttyinfo *ti));
  205. Xvoid sanetty DCLPROTO((struct ttyinfo *ti));
  206. Xvoid adjustwinsize DCLPROTO((void));
  207. Xint zyztem DCLPROTO((char *s,char *t));
  208. Xint waitfork DCLPROTO((void));
  209. Xint movefd DCLPROTO((int fd));
  210. Xvoid redup DCLPROTO((int x,int y));
  211. Xvoid settrap DCLPROTO((int t0,List l));
  212. Xvoid unsettrap DCLPROTO((int t0));
  213. Xvoid dotrap DCLPROTO((int sig));
  214. Xvoid ztrncpy DCLPROTO((char *s,char *t,int len));
  215. Xvoid strucpy DCLPROTO((char **s,char *t));
  216. Xvoid struncpy DCLPROTO((char **s,char *t,int n));
  217. Xvoid checkrmall DCLPROTO((char *s));
  218. Xint getquery DCLPROTO((void));
  219. Xvoid spscannodis DCLPROTO((char *s,char *cn));
  220. Xvoid spscan DCLPROTO((char *s,char *junk));
  221. Xvoid spckword DCLPROTO((char **s,char **s2,char **tptr,int cmd,int ask));
  222. Xint ztrftime DCLPROTO((char *buf,int bufsize,char *fmt,struct tm *tm));
  223. Xchar *join DCLPROTO((char **arr,int delim));
  224. Xchar *spacejoin DCLPROTO((char **s));
  225. Xchar *colonjoin DCLPROTO((char **s));
  226. Xchar **colonsplit DCLPROTO((char *s));
  227. Xchar **spacesplit DCLPROTO((char *s));
  228. XList getshfunc DCLPROTO((char *nam));
  229. Xvptr allocnode DCLPROTO((int type));
  230. Xvptr dupstruct DCLPROTO((vptr a));
  231. Xvoid freestruct DCLPROTO((vptr a));
  232. XLklist duplist DCLPROTO((Lklist l,VFunc func));
  233. Xchar **mkarray DCLPROTO((char *s));
  234. Xvoid feep DCLPROTO((void));
  235. Xvoid freearray DCLPROTO((char **s));
  236. Xint equalsplit DCLPROTO((char *s,char **t));
  237. Xvoid simplifyright DCLPROTO((List l));
  238. Xvoid inittyptab DCLPROTO((void));
  239. Xchar **arrdup DCLPROTO((char **s));
  240. Xchar *spname  DCLPROTO((char *oldname));
  241. Xint mindist DCLPROTO((char *dir,char *guess,char *best));
  242. Xint spdist DCLPROTO((char *s,char *t,int thresh));
  243. Xchar *zgetenv DCLPROTO((char *s));
  244. Xint tulower DCLPROTO((int c));
  245. Xint tuupper DCLPROTO((int c));
  246. Xvoid setcbreak DCLPROTO((void));
  247. Xint getlineleng DCLPROTO((void));
  248. Xvoid unsetcbreak DCLPROTO((void));
  249. Xvoid attachtty DCLPROTO((long pgrp));
  250. Xlong gettygrp DCLPROTO((void));
  251. SHAR_EOF
  252. chmod 0644 zsh2.2/src/utils.pro ||
  253. echo 'restore of zsh2.2/src/utils.pro failed'
  254. Wc_c="`wc -c < 'zsh2.2/src/utils.pro'`"
  255. test 3277 -eq "$Wc_c" ||
  256.     echo 'zsh2.2/src/utils.pro: original size 3277, current size' "$Wc_c"
  257. rm -f _shar_wnt_.tmp
  258. fi
  259. # ============= zsh2.2/src/watch.pro ==============
  260. if test -f 'zsh2.2/src/watch.pro' -a X"$1" != X"-c"; then
  261.     echo 'x - skipping zsh2.2/src/watch.pro (File already exists)'
  262.     rm -f _shar_wnt_.tmp
  263. else
  264. > _shar_wnt_.tmp
  265. echo 'x - extracting zsh2.2/src/watch.pro (Text)'
  266. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/watch.pro' &&
  267. Xtime_t getlogtime DCLPROTO((struct utmp *u,int inout));
  268. Xvoid watchlog2 DCLPROTO((int inout,struct utmp *u,char *fmt));
  269. Xvoid watchlog DCLPROTO((int inout,struct utmp *u,char **w,char *fmt));
  270. Xint ucmp DCLPROTO((struct utmp *u,struct utmp *v));
  271. Xvoid readwtab DCLPROTO((void));
  272. Xvoid dowatch DCLPROTO((void));
  273. Xint bin_log DCLPROTO((char *nam,char **argv,char *ops,int func));
  274. SHAR_EOF
  275. chmod 0644 zsh2.2/src/watch.pro ||
  276. echo 'restore of zsh2.2/src/watch.pro failed'
  277. Wc_c="`wc -c < 'zsh2.2/src/watch.pro'`"
  278. test 371 -eq "$Wc_c" ||
  279.     echo 'zsh2.2/src/watch.pro: original size 371, current size' "$Wc_c"
  280. rm -f _shar_wnt_.tmp
  281. fi
  282. # ============= zsh2.2/src/zle_bindings.pro ==============
  283. if test -f 'zsh2.2/src/zle_bindings.pro' -a X"$1" != X"-c"; then
  284.     echo 'x - skipping zsh2.2/src/zle_bindings.pro (File already exists)'
  285.     rm -f _shar_wnt_.tmp
  286. else
  287. > _shar_wnt_.tmp
  288. echo 'x - extracting zsh2.2/src/zle_bindings.pro (Text)'
  289. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_bindings.pro' &&
  290. SHAR_EOF
  291. chmod 0644 zsh2.2/src/zle_bindings.pro ||
  292. echo 'restore of zsh2.2/src/zle_bindings.pro failed'
  293. Wc_c="`wc -c < 'zsh2.2/src/zle_bindings.pro'`"
  294. test 0 -eq "$Wc_c" ||
  295.     echo 'zsh2.2/src/zle_bindings.pro: original size 0, current size' "$Wc_c"
  296. rm -f _shar_wnt_.tmp
  297. fi
  298. # ============= zsh2.2/src/zle_main.pro ==============
  299. if test -f 'zsh2.2/src/zle_main.pro' -a X"$1" != X"-c"; then
  300.     echo 'x - skipping zsh2.2/src/zle_main.pro (File already exists)'
  301.     rm -f _shar_wnt_.tmp
  302. else
  303. > _shar_wnt_.tmp
  304. echo 'x - extracting zsh2.2/src/zle_main.pro (Text)'
  305. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_main.pro' &&
  306. Xvoid setterm DCLPROTO((void));
  307. Xvoid unsetterm DCLPROTO((void));
  308. Xvoid ungetkey DCLPROTO((int ch));
  309. Xvoid ungetkeys DCLPROTO((char *s,int len));
  310. Xunsigned int getkey DCLPROTO((int tmok));
  311. Xunsigned char *zleread DCLPROTO((unsigned char *ppt,unsigned char *ppt2,int plen));
  312. Xint getkeycmd DCLPROTO((void));
  313. Xvoid sendstring DCLPROTO((void));
  314. XKey makefunckey DCLPROTO((int fun));
  315. Xvoid initxbindtab DCLPROTO((void));
  316. Xchar *getkeystring DCLPROTO((char *s,int *len));
  317. Xvoid printbind DCLPROTO((char *s,int len));
  318. Xvoid printbinding DCLPROTO((char *str,Key k));
  319. Xint bin_bindkey DCLPROTO((char *name,char **argv,char *ops,int junc));
  320. Xvoid freekey DCLPROTO((vptr x));
  321. Xvoid drainoutput DCLPROTO((void));
  322. SHAR_EOF
  323. chmod 0644 zsh2.2/src/zle_main.pro ||
  324. echo 'restore of zsh2.2/src/zle_main.pro failed'
  325. Wc_c="`wc -c < 'zsh2.2/src/zle_main.pro'`"
  326. test 686 -eq "$Wc_c" ||
  327.     echo 'zsh2.2/src/zle_main.pro: original size 686, current size' "$Wc_c"
  328. rm -f _shar_wnt_.tmp
  329. fi
  330. # ============= zsh2.2/src/zle_refresh.pro ==============
  331. if test -f 'zsh2.2/src/zle_refresh.pro' -a X"$1" != X"-c"; then
  332.     echo 'x - skipping zsh2.2/src/zle_refresh.pro (File already exists)'
  333.     rm -f _shar_wnt_.tmp
  334. else
  335. > _shar_wnt_.tmp
  336. echo 'x - extracting zsh2.2/src/zle_refresh.pro (Text)'
  337. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_refresh.pro' &&
  338. Xvoid resetvideo DCLPROTO((void));
  339. Xint scrollwindow DCLPROTO((void));
  340. Xvoid refresh DCLPROTO((void));
  341. Xvoid refreshline DCLPROTO((int ln));
  342. Xvoid moveto DCLPROTO((int ln,int cl));
  343. Xvoid tcmultout DCLPROTO((int cap,int multcap,int ct));
  344. Xvoid tc_rightcurs DCLPROTO((int ct));
  345. Xvoid tc_downcurs DCLPROTO((int ct));
  346. Xvoid tcout DCLPROTO((int cap));
  347. Xvoid tcoutarg DCLPROTO((int cap,int arg));
  348. Xvoid clearscreen DCLPROTO((void));
  349. Xvoid redisplay DCLPROTO((void));
  350. Xvoid trashzle DCLPROTO((void));
  351. Xvoid singlerefresh DCLPROTO((void));
  352. Xvoid singmoveto DCLPROTO((int pos));
  353. Xint streqct DCLPROTO((char *s,char *t));
  354. SHAR_EOF
  355. chmod 0644 zsh2.2/src/zle_refresh.pro ||
  356. echo 'restore of zsh2.2/src/zle_refresh.pro failed'
  357. Wc_c="`wc -c < 'zsh2.2/src/zle_refresh.pro'`"
  358. test 596 -eq "$Wc_c" ||
  359.     echo 'zsh2.2/src/zle_refresh.pro: original size 596, current size' "$Wc_c"
  360. rm -f _shar_wnt_.tmp
  361. fi
  362. # ============= zsh2.2/src/zle_vi.pro ==============
  363. if test -f 'zsh2.2/src/zle_vi.pro' -a X"$1" != X"-c"; then
  364.     echo 'x - skipping zsh2.2/src/zle_vi.pro (File already exists)'
  365.     rm -f _shar_wnt_.tmp
  366. else
  367. > _shar_wnt_.tmp
  368. echo 'x - extracting zsh2.2/src/zle_vi.pro (Text)'
  369. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_vi.pro' &&
  370. Xint vigetkey DCLPROTO((void));
  371. Xint getvirange DCLPROTO((int wf));
  372. Xvoid viaddnext DCLPROTO((void));
  373. Xvoid viaddeol DCLPROTO((void));
  374. Xvoid viinsert DCLPROTO((void));
  375. Xvoid viinsertbol DCLPROTO((void));
  376. Xvoid videlete DCLPROTO((void));
  377. Xvoid vichange DCLPROTO((void));
  378. Xvoid visubstitute DCLPROTO((void));
  379. Xvoid vichangeeol DCLPROTO((void));
  380. Xvoid vichangewholeline DCLPROTO((void));
  381. Xvoid viyank DCLPROTO((void));
  382. Xvoid viyankeol DCLPROTO((void));
  383. Xvoid vireplace DCLPROTO((void));
  384. Xvoid vireplacechars DCLPROTO((void));
  385. Xvoid vicmdmode DCLPROTO((void));
  386. Xvoid viopenlinebelow DCLPROTO((void));
  387. Xvoid viopenlineabove DCLPROTO((void));
  388. Xvoid vioperswapcase DCLPROTO((void));
  389. Xvoid virepeatchange DCLPROTO((void));
  390. Xvoid viindent DCLPROTO((void));
  391. Xvoid viunindent DCLPROTO((void));
  392. SHAR_EOF
  393. chmod 0644 zsh2.2/src/zle_vi.pro ||
  394. echo 'restore of zsh2.2/src/zle_vi.pro failed'
  395. Wc_c="`wc -c < 'zsh2.2/src/zle_vi.pro'`"
  396. test 761 -eq "$Wc_c" ||
  397.     echo 'zsh2.2/src/zle_vi.pro: original size 761, current size' "$Wc_c"
  398. rm -f _shar_wnt_.tmp
  399. fi
  400. # ============= zsh2.2/src/parse.pro ==============
  401. if test -f 'zsh2.2/src/parse.pro' -a X"$1" != X"-c"; then
  402.     echo 'x - skipping zsh2.2/src/parse.pro (File already exists)'
  403.     rm -f _shar_wnt_.tmp
  404. else
  405. > _shar_wnt_.tmp
  406. echo 'x - extracting zsh2.2/src/parse.pro (Text)'
  407. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/parse.pro' &&
  408. XList parse_event DCLPROTO((void));
  409. XList par_event DCLPROTO((void));
  410. XList parse_list DCLPROTO((void));
  411. XList par_list DCLPROTO((void));
  412. XList par_list1 DCLPROTO((void));
  413. XSublist par_sublist DCLPROTO((void));
  414. XSublist par_sublist2 DCLPROTO((void));
  415. XPline par_pline DCLPROTO((void));
  416. XCmd par_cmd DCLPROTO((void));
  417. Xvoid par_for DCLPROTO((Cmd c));
  418. Xvoid par_case DCLPROTO((Cmd c));
  419. Xvoid par_if DCLPROTO((Cmd c));
  420. Xvoid par_while DCLPROTO((Cmd c));
  421. Xvoid par_repeat DCLPROTO((Cmd c));
  422. Xvoid par_subsh DCLPROTO((Cmd c));
  423. Xvoid par_funcdef DCLPROTO((Cmd c));
  424. Xvoid par_time DCLPROTO((Cmd c));
  425. Xvoid par_dinbrack DCLPROTO((Cmd c));
  426. XCmd par_simple DCLPROTO((Cmd c));
  427. XCond par_cond DCLPROTO((void));
  428. XCond par_cond_1 DCLPROTO((void));
  429. XCond par_cond_2 DCLPROTO((void));
  430. Xvoid par_redir DCLPROTO((Lklist l));
  431. XLklist par_wordlist DCLPROTO((void));
  432. XLklist par_nl_wordlist DCLPROTO((void));
  433. Xint getfdstr DCLPROTO((char *s));
  434. XCond par_cond_double DCLPROTO((char *a,char *b));
  435. XCond par_cond_triple DCLPROTO((char *a,char *b,char *c));
  436. Xvoid yyerror DCLPROTO((void));
  437. SHAR_EOF
  438. chmod 0644 zsh2.2/src/parse.pro ||
  439. echo 'restore of zsh2.2/src/parse.pro failed'
  440. Wc_c="`wc -c < 'zsh2.2/src/parse.pro'`"
  441. test 1036 -eq "$Wc_c" ||
  442.     echo 'zsh2.2/src/parse.pro: original size 1036, current size' "$Wc_c"
  443. rm -f _shar_wnt_.tmp
  444. fi
  445. # ============= zsh2.2/src/zle_tricky.pro ==============
  446. if test -f 'zsh2.2/src/zle_tricky.pro' -a X"$1" != X"-c"; then
  447.     echo 'x - skipping zsh2.2/src/zle_tricky.pro (File already exists)'
  448.     rm -f _shar_wnt_.tmp
  449. else
  450. > _shar_wnt_.tmp
  451. echo 'x - extracting zsh2.2/src/zle_tricky.pro (Text)'
  452. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_tricky.pro' &&
  453. Xint usetab DCLPROTO((void));
  454. Xvoid completeword DCLPROTO((void));
  455. Xvoid menucompleteword DCLPROTO((void));
  456. Xvoid listchoices DCLPROTO((void));
  457. Xvoid spellword DCLPROTO((void));
  458. Xvoid deletecharorlist DCLPROTO((void));
  459. Xvoid expandword DCLPROTO((void));
  460. Xvoid expandorcomplete DCLPROTO((void));
  461. Xvoid menuexpandorcomplete DCLPROTO((void));
  462. Xvoid listexpand DCLPROTO((void));
  463. Xvoid reversemenucomplete DCLPROTO((void));
  464. Xvoid acceptandmenucomplete DCLPROTO((void));
  465. Xvoid docomplete DCLPROTO((int lst));
  466. Xvoid do_menucmp DCLPROTO((int lst));
  467. Xchar *get_comp_string DCLPROTO((void));
  468. Xvoid doexpansion DCLPROTO((char *s,int lst,int lincmd));
  469. Xvoid gotword DCLPROTO((char *s));
  470. Xvoid inststrlen DCLPROTO((char *s,int l));
  471. Xvoid addmatch DCLPROTO((char *s));
  472. Xvoid addcmdmatch DCLPROTO((char *s,char *t));
  473. Xvoid addcmddirparam DCLPROTO((char *s,char *t));
  474. Xvoid addcmdnodis DCLPROTO((char *s,char *t));
  475. Xvoid maketildelist DCLPROTO((char    *s));
  476. Xint Isdir DCLPROTO((char *s));
  477. Xint isdir DCLPROTO((char *t,char *s));
  478. Xvoid docompletion DCLPROTO((char *s,int lst,int incmd));
  479. Xchar **get_user_var DCLPROTO((char *nam));
  480. Xvoid gen_matches_glob DCLPROTO((char *s,int incmd));
  481. Xvoid gen_matches_reg DCLPROTO((char *s,int incmd,int regfiles));
  482. Xvoid do_fignore DCLPROTO((char *origstr));
  483. Xvoid do_ambiguous DCLPROTO((char *s));
  484. Xvoid do_single DCLPROTO((char *s));
  485. Xvoid do_ambig_menu DCLPROTO((char *s));
  486. Xint strpfx DCLPROTO((char *s,char *t));
  487. Xint pfxlen DCLPROTO((char *s,char *t));
  488. Xvoid listmatches DCLPROTO((Lklist l,char *apps));
  489. Xvoid selectlist DCLPROTO((Lklist l));
  490. Xint doexpandhist DCLPROTO((void));
  491. Xvoid magicspace DCLPROTO((void));
  492. Xvoid expandhistory DCLPROTO((void));
  493. Xchar *getcurcmd DCLPROTO((void));
  494. Xvoid processcmd DCLPROTO((void));
  495. Xvoid expandcmdpath DCLPROTO((void));
  496. Xvoid freemenu DCLPROTO((void));
  497. Xint inarray DCLPROTO((char *s, char **a));
  498. SHAR_EOF
  499. chmod 0644 zsh2.2/src/zle_tricky.pro ||
  500. echo 'restore of zsh2.2/src/zle_tricky.pro failed'
  501. Wc_c="`wc -c < 'zsh2.2/src/zle_tricky.pro'`"
  502. test 1817 -eq "$Wc_c" ||
  503.     echo 'zsh2.2/src/zle_tricky.pro: original size 1817, current size' "$Wc_c"
  504. rm -f _shar_wnt_.tmp
  505. fi
  506. # ============= zsh2.2/src/parse.c ==============
  507. if test -f 'zsh2.2/src/parse.c' -a X"$1" != X"-c"; then
  508.     echo 'x - skipping zsh2.2/src/parse.c (File already exists)'
  509.     rm -f _shar_wnt_.tmp
  510. else
  511. > _shar_wnt_.tmp
  512. echo 'x - extracting zsh2.2/src/parse.c (Text)'
  513. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/parse.c' &&
  514. X/*
  515. X *
  516. X * parse.c - parser
  517. X *
  518. X * This file is part of zsh, the Z shell.
  519. X *
  520. X * This software is Copyright 1992 by Paul Falstad
  521. X *
  522. X * Permission is hereby granted to copy, reproduce, redistribute or otherwise
  523. X * use this software as long as: there is no monetary profit gained
  524. X * specifically from the use or reproduction of this software, it is not
  525. X * sold, rented, traded or otherwise marketed, and this copyright notice is
  526. X * included prominently in any copy made. 
  527. X *
  528. X * The author make no claims as to the fitness or correctness of this software
  529. X * for any use whatsoever, and it is provided as is. Any use of this software
  530. X * is at the user's own risk. 
  531. X *
  532. X */
  533. X
  534. X#include "zsh.h"
  535. X#include "funcs.h"
  536. X
  537. X#define YYERROR { tok = LEXERR; return NULL; }
  538. X#define YYERRORV { tok = LEXERR; return; }
  539. X
  540. X#define make_list() allocnode(N_LIST)
  541. X#define make_sublist() allocnode(N_SUBLIST)
  542. X#define make_pline() allocnode(N_PLINE)
  543. X#define make_cmd() allocnode(N_CMD)
  544. X#define make_forcmd() allocnode(N_FOR)
  545. X#define make_casecmd() allocnode(N_CASE)
  546. X#define make_ifcmd() allocnode(N_IF)
  547. X#define make_whilecmd() allocnode(N_WHILE)
  548. X#define make_varnode() allocnode(N_VARASG)
  549. X#define make_cond() allocnode(N_COND)
  550. X
  551. X/*
  552. X * event    : ENDINPUT
  553. X *            | SEPER
  554. X *            | sublist [ SEPER | AMPER ]
  555. X */
  556. XList parse_event() /**/
  557. X{
  558. X    tok = ENDINPUT;
  559. X    incmdpos = 1;
  560. X    yylex();
  561. X    return par_event();
  562. X}
  563. X
  564. XList par_event() /**/
  565. X{
  566. XSublist sl;
  567. XList l = NULL;
  568. X
  569. X    while (tok == SEPER) {
  570. X        if (isnewlin > 0) return NULL;
  571. X        yylex();
  572. X    }
  573. X    if (tok == ENDINPUT) return NULL;
  574. X    if (sl = par_sublist())
  575. X        if (tok == ENDINPUT) {
  576. X            l = make_list();
  577. X            l->type = SYNC; l->left = sl;
  578. X        } else if (tok == SEPER) {
  579. X            l = make_list();
  580. X            l->type = SYNC; l->left = sl;
  581. X            if (isnewlin <= 0) yylex();
  582. X        } else if (tok == AMPER) {
  583. X            l = make_list();
  584. X            l->type = ASYNC; l->left = sl;
  585. X            yylex();
  586. X        } else
  587. X            l = NULL;
  588. X    if (!l) {
  589. X        if (errflag) { yyerror(); return NULL; }
  590. X        yyerror();
  591. X        errflag = 0;
  592. X        if (isnewlin <= 0) {
  593. X            int c;
  594. X
  595. X            hwbegin();
  596. X            while ((c = hgetc()) != '\n' && !lexstop);
  597. X            if (c == '\n') hungetc('\n');
  598. X            hwaddc(HISTSPACE);
  599. X            hwadd();
  600. X        }
  601. X        errflag = 1;
  602. X        return NULL;
  603. X    } else {
  604. X        l->right = par_event();
  605. X    }
  606. X    return l;
  607. X}
  608. X
  609. XList parse_list() /**/
  610. X{
  611. X    tok = ENDINPUT;
  612. X    incmdpos = 1;
  613. X    yylex();
  614. X    return par_list();
  615. X}
  616. X
  617. X/*
  618. X * list    : { SEPER } [ sublist [ { SEPER | AMPER } list ] ]
  619. X */
  620. XList par_list() /**/
  621. X{
  622. XSublist sl;
  623. XList l = NULL;
  624. X
  625. X    while (tok == SEPER) yylex();
  626. X    if (sl = par_sublist())
  627. X        if (tok == SEPER || tok == AMPER) {
  628. X            l = make_list();
  629. X            l->left = sl;
  630. X            l->type = (tok == SEPER) ? SYNC : ASYNC;
  631. X            incmdpos = 1;
  632. X            while (tok == SEPER || tok == AMPER) yylex();
  633. X            l->right = par_list();
  634. X        } else {
  635. X            l = make_list();
  636. X            l->left = sl;
  637. X            l->type = SYNC;
  638. X        }
  639. X    return l;
  640. X}
  641. X
  642. XList par_list1() /**/
  643. X{
  644. XSublist sl;
  645. XList l = NULL;
  646. X
  647. X    if (sl = par_sublist()) {
  648. X        l = make_list();
  649. X        l->type = SYNC;
  650. X        l->left = sl;
  651. X    }
  652. X    return l;
  653. X}
  654. X
  655. X/*
  656. X * sublist    : sublist2 [ ( DBAR | DAMPER ) { SEPER } sublist ]
  657. X */
  658. XSublist par_sublist() /**/
  659. X{
  660. XSublist sl;
  661. X
  662. X    if (sl = par_sublist2())
  663. X        if (tok == DBAR || tok == DAMPER) {
  664. X            int qtok = tok;
  665. X            yylex();
  666. X            while (tok == SEPER) yylex();
  667. X            sl->right = par_sublist();
  668. X            sl->type = (qtok == DBAR) ? ORNEXT : ANDNEXT;
  669. X        }
  670. X    return sl;
  671. X}
  672. X
  673. X/*
  674. X * sublist2    : [ COPROC | BANG ] pline
  675. X */
  676. XSublist par_sublist2() /**/
  677. X{
  678. XSublist sl;
  679. XPline p;
  680. X
  681. X    sl = make_sublist();
  682. X    if (tok == COPROC) { sl->flags |= PFLAG_COPROC; yylex(); }
  683. X    else if (tok == BANG) { sl->flags |= PFLAG_NOT; yylex(); }
  684. X    if (!(p = par_pline()) && !sl->flags)
  685. X        return NULL;
  686. X    sl->left = p;
  687. X    return sl;
  688. X}
  689. X
  690. X/*
  691. X * pline    : cmd [ ( BAR | BARAMP ) { SEPER } pline ]
  692. X */
  693. XPline par_pline() /**/
  694. X{
  695. XCmd c;
  696. XPline p,p2;
  697. X
  698. X    if (!(c = par_cmd()))
  699. X        return NULL;
  700. X    if (tok == BAR) {
  701. X        yylex();
  702. X        while (tok == SEPER) yylex();
  703. X        p2 = par_pline();
  704. X        p = make_pline();
  705. X        p->left = c; p->right = p2; p->type = PIPE;
  706. X        return p;
  707. X    } else if (tok == BARAMP) {
  708. X        struct redir *rdr = alloc(sizeof *rdr);
  709. X        rdr->type = MERGE; rdr->fd1 = 2; rdr->fd2 = 1;
  710. X        addnode(c->redir,rdr);
  711. X
  712. X        yylex();
  713. X        p2 = par_pline();
  714. X        p = make_pline();
  715. X        p->left = c; p->right = p2; p->type = PIPE;
  716. X        return p;
  717. X    } else {
  718. X        p = make_pline();
  719. X        p->left = c; p->type = END;
  720. X        return p;
  721. X    }
  722. X}
  723. X
  724. X/*
  725. X * cmd    : { redir } ( for | case | if | while | repeat |
  726. X *                subsh | funcdef | time | dinbrack | simple ) { redir }
  727. X */
  728. XCmd par_cmd() /**/
  729. X{
  730. XCmd c;
  731. X
  732. X    c = make_cmd();
  733. X    c->args = newlist();
  734. X    c->redir = newlist();
  735. X    c->vars = newlist();
  736. X    while (IS_REDIROP(tok))
  737. X        par_redir(c->redir);
  738. X    switch (tok) {
  739. X    case FOR: case FOREACH: case SELECT: par_for(c); break;
  740. X    case CASE: par_case(c); break;
  741. X    case IF: par_if(c); break;
  742. X    case WHILE: case UNTIL: par_while(c); break;
  743. X    case REPEAT: par_repeat(c); break;
  744. X    case INPAR: case INBRACE: par_subsh(c); break;
  745. X    case FUNC: par_funcdef(c); break;
  746. X    case TIME: par_time(c); break;
  747. X    case DINBRACK: par_dinbrack(c); break;
  748. X    default: if (!par_simple(c)) return NULL; break;
  749. X    }
  750. X    while (IS_REDIROP(tok))
  751. X        par_redir(c->redir);
  752. X    incmdpos = 1;
  753. X    incasepat = 0;
  754. X    incond = 0;
  755. X    return c;
  756. X}
  757. X
  758. X/*
  759. X * for    : ( FOR[EACH] | SELECT ) name ( "in" wordlist | INPAR wordlist OUTPAR )
  760. X                { SEPER } ( DO list DONE | INBRACE list OUTBRACE |
  761. X                list ZEND | list1 )
  762. X */
  763. Xvoid par_for(c) /**/
  764. XCmd c;
  765. X{
  766. Xstruct forcmd *f;
  767. Xint csh = (tok == FOREACH || isset(CSHJUNKIELOOPS));
  768. X
  769. X    f = make_forcmd();
  770. X    c->type = (tok == SELECT) ? CSELECT : CFOR;
  771. X    incmdpos = 0;
  772. X    yylex();
  773. X    if (tok != STRING) YYERRORV;
  774. X    f->name = tokstr;
  775. X    incmdpos = 1;
  776. X    yylex();
  777. X    if (tok == STRING && !strcmp(tokstr,"in")) {
  778. X        f->inflag = 1;
  779. X        incmdpos = 0;
  780. X        yylex();
  781. X        c->args = par_wordlist();
  782. X        if (tok != SEPER) YYERRORV;
  783. X    } else if (tok == INPAR) {
  784. X        f->inflag = 1;
  785. X        incmdpos = 0;
  786. X        yylex();
  787. X        c->args = par_nl_wordlist();
  788. X        if (tok != OUTPAR) YYERRORV;
  789. X        incmdpos = 1;
  790. X        yylex();
  791. X    }
  792. X    incmdpos = 1;
  793. X    while (tok == SEPER) yylex();
  794. X    if (tok == DO) {
  795. X        yylex();
  796. X        f->list = par_list();
  797. X        if (tok != DONE) YYERRORV;
  798. X        yylex();
  799. X    } else if (tok == INBRACE) {
  800. X        yylex();
  801. X        f->list = par_list();
  802. X        if (tok != OUTBRACE) YYERRORV;
  803. X        yylex();
  804. X    } else if (csh) {
  805. X        f->list = par_list();
  806. X        if (tok != ZEND) YYERRORV;
  807. X        yylex();
  808. X    } else if (isset(NOSHORTLOOPS)) {
  809. X        YYERRORV;
  810. X    } else
  811. X        f->list = par_list1();
  812. X    c->u.forcmd = f;
  813. X}
  814. X
  815. X/*
  816. X * case    : CASE STRING { SEPER } ( "in" | INBRACE )
  817. X                { { SEPER } STRING { BAR STRING } OUTPAR list [ DSEMI ] }
  818. X                { SEPER } ( "esac" | OUTBRACE )
  819. X */
  820. Xvoid par_case(c) /**/
  821. XCmd c;
  822. X{
  823. Xstruct casecmd **ccp;
  824. Xint brflag;
  825. X
  826. X    c->type = CCASE;
  827. X    incmdpos = 0;
  828. X    yylex();
  829. X    if (tok != STRING) YYERRORV;
  830. X    addnode(c->args,tokstr);
  831. X    incmdpos = 1;
  832. X    yylex();
  833. X    while (tok == SEPER) yylex();
  834. X    if (!(tok == STRING && !strcmp(tokstr,"in")) && tok != INBRACE) YYERRORV;
  835. X    brflag = (tok == INBRACE);
  836. X    incasepat = 1;
  837. X    incmdpos = 0;
  838. X    yylex();
  839. X    ccp = &c->u.casecmd;
  840. X    for (;;) {
  841. X        char *str;
  842. X        struct casecmd *cc;
  843. X
  844. X        *ccp = cc = make_casecmd();
  845. X        while (tok == SEPER) yylex();
  846. X        if (tok == OUTBRACE) {
  847. X            yylex();
  848. X            break;
  849. X        }
  850. X        if (tok != STRING) YYERRORV;
  851. X        if (!strcmp(tokstr,"esac")) {
  852. X            yylex();
  853. X            break;
  854. X        }
  855. X        str = tokstr;
  856. X        yylex();
  857. X        while (tok == BAR) {
  858. X            char *str2;
  859. X            int sl = strlen(str);
  860. X
  861. X            yylex();
  862. X            if (tok != STRING) YYERRORV;
  863. X            str2 = alloc(sl+strlen(tokstr)+1);
  864. X            strcpy(str2,str);
  865. X            str2[sl] = Bar;
  866. X            strcpy(str2+sl+1,tokstr);
  867. X            str = str2;
  868. X            yylex();
  869. X        }
  870. X        if (tok != OUTPAR) YYERRORV;
  871. X        incasepat = 0;
  872. X        incmdpos = 1;
  873. X        yylex();
  874. X        cc->pat = str;
  875. X        cc->list = par_list();
  876. X        ccp = &cc->next;
  877. X        if ((tok == ESAC && !brflag) || (tok == OUTBRACE && brflag)) {
  878. X            yylex();
  879. X            break;
  880. X        }
  881. X        if (tok != DSEMI) YYERRORV;
  882. X        incasepat = 1;
  883. X        incmdpos = 0;
  884. X        yylex();
  885. X    }
  886. X    *ccp = NULL;
  887. X}
  888. X
  889. X/*
  890. X * if    : { ( IF | ELIF ) { SEPER } ( INPAR list OUTPAR | list )
  891. X            { SEPER } ( THEN list | INBRACE list OUTBRACE | list1 ) }
  892. X            [ FI | ELSE list FI | ELSE { SEPER } INBRACE list OUTBRACE ]
  893. X            (you get the idea...?)
  894. X */
  895. Xvoid par_if(c) /**/
  896. XCmd c;
  897. X{
  898. Xstruct ifcmd *i,**ip;
  899. Xint xtok;
  900. X
  901. X    c->type = CIF;
  902. X    ip = &c->u.ifcmd;
  903. X    for (;;) {
  904. X        xtok = tok;
  905. X        yylex();
  906. X        if (xtok == FI)
  907. X            break;
  908. X        while (tok == SEPER) yylex();
  909. X        if (xtok == ELSE)
  910. X            break;
  911. X        if (!(xtok == IF || xtok == ELIF)) YYERRORV;
  912. X        *ip = i = make_ifcmd();
  913. X        ip = &i->next;
  914. X        if (tok == INPAR) {
  915. X            yylex();
  916. X            i->ifl = par_list();
  917. X            if (tok != OUTPAR) YYERRORV;
  918. X            incmdpos = 1;
  919. X            yylex();
  920. X        } else {
  921. X            i->ifl = par_list();
  922. X            incmdpos = 1;
  923. X        }
  924. X        while (tok == SEPER) yylex();
  925. X        xtok = FI;
  926. X        if (tok == THEN) {
  927. X            yylex();
  928. X            i->thenl = par_list();
  929. X            incmdpos = 1;
  930. X        } else if (tok == INBRACE) {
  931. X            yylex();
  932. X            i->thenl = par_list();
  933. X            if (tok != OUTBRACE) YYERRORV;
  934. X            yylex();
  935. X            incmdpos = 1;
  936. X            if (tok == SEPER) break;
  937. X        } else if (isset(NOSHORTLOOPS)) {
  938. X            YYERRORV;
  939. X        } else {
  940. X            i->thenl = par_list1();
  941. X            incmdpos = 1;
  942. X            break;
  943. X        }
  944. X    }
  945. X    if (xtok == ELSE) {
  946. X        *ip = i = make_ifcmd();
  947. X        if (tok == INBRACE) {
  948. X            yylex();
  949. X            i->thenl = par_list();
  950. X            if (tok != OUTBRACE) YYERRORV;
  951. X            yylex();
  952. X        } else {
  953. X            i->thenl = par_list();
  954. X            if (tok != FI) YYERRORV;
  955. X            yylex();
  956. X        }
  957. X    }
  958. X}
  959. X
  960. X/*
  961. X * while    : ( WHILE | UNTIL ) ( INPAR list OUTPAR | list ) { SEPER }
  962. X                ( DO list DONE | INBRACE list OUTBRACE | list ZEND )
  963. X */
  964. Xvoid par_while(c) /**/
  965. XCmd c;
  966. X{
  967. Xstruct whilecmd *w;
  968. X
  969. X    c->type = CWHILE;
  970. X    w = c->u.whilecmd = make_whilecmd();
  971. X    w->cond = (tok == UNTIL);
  972. X    yylex();
  973. X    if (tok == INPAR) {
  974. X        yylex();
  975. X        w->cont = par_list();
  976. X        if (tok != OUTPAR) YYERRORV;
  977. X        yylex();
  978. X    } else {
  979. X        w->cont = par_list();
  980. X    }
  981. X    incmdpos = 1;
  982. X    while (tok == SEPER) yylex();
  983. X    if (tok == DO) {
  984. X        yylex();
  985. X        w->loop = par_list();
  986. X        if (tok != DONE) YYERRORV;
  987. X        yylex();
  988. X    } else if (tok == INBRACE) {
  989. X        yylex();
  990. X        w->loop = par_list();
  991. X        if (tok != OUTBRACE) YYERRORV;
  992. X        yylex();
  993. X    } else if (isset(CSHJUNKIELOOPS)) {
  994. X        w->loop = par_list();
  995. X        if (tok != ZEND) YYERRORV;
  996. X        yylex();
  997. X    } else
  998. X        YYERRORV;
  999. X}
  1000. X
  1001. X/*
  1002. X * repeat    : REPEAT STRING { SEPER } ( DO list DONE | list1 )
  1003. X */
  1004. Xvoid par_repeat(c) /**/
  1005. XCmd c;
  1006. X{
  1007. X    c->type = CREPEAT;
  1008. X    incmdpos = 0;
  1009. X    yylex();
  1010. X    if (tok != STRING) YYERRORV;
  1011. X    addnode(c->args,tokstr);
  1012. X    incmdpos = 1;
  1013. X    yylex();
  1014. X    while (tok == SEPER) yylex();
  1015. X    if (tok == DO) {
  1016. X        yylex();
  1017. X        c->u.list = par_list();
  1018. X        if (tok != DONE) YYERRORV;
  1019. X        yylex();
  1020. X    } else {
  1021. X        c->u.list = par_list1();
  1022. X    }
  1023. X}
  1024. X
  1025. X/*
  1026. X * subsh    : ( INPAR | INBRACE ) list ( OUTPAR | OUTBRACE )
  1027. X */
  1028. Xvoid par_subsh(c) /**/
  1029. XCmd c;
  1030. X{
  1031. X    c->type = (tok == INPAR) ? SUBSH : CURSH;
  1032. X    yylex();
  1033. X    c->u.list = par_list();
  1034. X    if (tok != ((c->type == SUBSH) ? OUTPAR : OUTBRACE)) YYERRORV;
  1035. X    yylex();
  1036. X}
  1037. X
  1038. X/*
  1039. X * funcdef    : FUNCTION wordlist [ INOUTPAR ] { SEPER }
  1040. X *                    ( list1 | INBRACE list OUTBRACE )
  1041. X */
  1042. Xvoid par_funcdef(c) /**/
  1043. XCmd c;
  1044. X{
  1045. X    nocorrect = 1;
  1046. X    incmdpos = 0;
  1047. X    yylex();
  1048. X    c->type = FUNCDEF;
  1049. X    c->args = newlist();
  1050. X    while (tok == STRING) {
  1051. X        if (*tokstr == Inbrace && !tokstr[1]) { tok = INBRACE; break; }
  1052. X        addnode(c->args,tokstr);
  1053. X        yylex();
  1054. X    }
  1055. X    nocorrect = 0;
  1056. X    incmdpos = 1;
  1057. X    if (tok == INOUTPAR) yylex();
  1058. X    while (tok == SEPER) yylex();
  1059. X    if (tok == INBRACE) {
  1060. X        yylex();
  1061. X        c->u.list = par_list();
  1062. X        if (tok != OUTBRACE) YYERRORV;
  1063. X        yylex();
  1064. X    } else if (isset(NOSHORTLOOPS)) {
  1065. X        YYERRORV;
  1066. X    } else
  1067. X        c->u.list = par_list1();
  1068. X}
  1069. X
  1070. X/*
  1071. X * time    : TIME sublist2
  1072. X */
  1073. Xvoid par_time(c) /**/
  1074. XCmd c;
  1075. X{
  1076. X    yylex();
  1077. X    c->type = ZCTIME;
  1078. X    c->u.pline = par_sublist2();
  1079. X}
  1080. X
  1081. X/*
  1082. X * dinbrack    : DINBRACK cond DOUTBRACK
  1083. X */
  1084. Xvoid par_dinbrack(c) /**/
  1085. XCmd c;
  1086. X{
  1087. X    c->type = COND;
  1088. X    incond = 1;
  1089. X    incmdpos = 0;
  1090. X    yylex();
  1091. X    c->u.cond = par_cond();
  1092. X    if (tok != DOUTBRACK) YYERRORV;
  1093. X    incond = 0;
  1094. X    incmdpos = 1;
  1095. X    yylex();
  1096. X}
  1097. X
  1098. X/*
  1099. X * simple    : { COMMAND | EXEC | NOGLOB | NOCORRECT | DASH }
  1100. X                    { STRING | ENVSTRING | ENVARRAY wordlist OUTPAR | redir }
  1101. X                    [ INOUTPAR { SEPER } ( list1 | INBRACE list OUTBRACE ) ]
  1102. X */
  1103. XCmd par_simple(c) /**/
  1104. XCmd c;
  1105. X{
  1106. Xint isnull = 1;
  1107. X
  1108. X    c->type = SIMPLE;
  1109. X    for (;;) {
  1110. X        if (tok == COMMAND) c->flags |= CFLAG_COMMAND;
  1111. X        else if (tok == EXEC) c->flags |= CFLAG_EXEC;
  1112. X        else if (tok == NOGLOB) c->flags |= CFLAG_NOGLOB;
  1113. X        else if (tok == NOCORRECT) nocorrect = 1;
  1114. X        else if (tok == DASH) c->flags = CFLAG_DASH;
  1115. X        else break;
  1116. X        yylex();
  1117. X    }
  1118. X    if (tok == AMPER) YYERROR;
  1119. X    for (;;) {
  1120. X        if (tok == STRING) {
  1121. X            incmdpos = 0;
  1122. X            addnode(c->args,tokstr);
  1123. X            yylex();
  1124. X        } else if (tok == ENVSTRING) {
  1125. X            struct varasg *v = make_varnode();
  1126. X            v->type = PMFLAG_s;
  1127. X            equalsplit(v->name = tokstr,&v->str);
  1128. X            addnode(c->vars,v);
  1129. X            yylex();
  1130. X        } else if (tok == ENVARRAY) {
  1131. X            struct varasg *v = make_varnode();
  1132. X            int oldcmdpos = incmdpos;
  1133. X            v->type = PMFLAG_A;
  1134. X            incmdpos = 0;
  1135. X            v->name = tokstr;
  1136. X            yylex();
  1137. X            v->arr = par_nl_wordlist();
  1138. X            if (tok != OUTPAR) YYERROR;
  1139. X            incmdpos = oldcmdpos;
  1140. X            yylex();
  1141. X            addnode(c->vars,v);
  1142. X        } else if (IS_REDIROP(tok)) {
  1143. X            par_redir(c->redir);
  1144. X        } else if (tok == INOUTPAR) {
  1145. X            incmdpos = 1;
  1146. X            yylex();
  1147. X            while (tok == SEPER) yylex();
  1148. X            if (tok == INBRACE) {
  1149. X                yylex();
  1150. X                c->u.list = par_list();
  1151. X                if (tok != OUTBRACE) YYERROR;
  1152. X                yylex();
  1153. X            } else if (isset(NOSHORTLOOPS)) {
  1154. X                YYERROR;
  1155. X            } else
  1156. X                c->u.list = par_list1();
  1157. X            c->type = FUNCDEF;
  1158. X        } else break;
  1159. X        isnull = 0;
  1160. X    }
  1161. X    if (isnull && !full(c->redir)) return NULL;
  1162. X    if (full(c->args)) {
  1163. X        if (underscore)
  1164. X            free(underscore);
  1165. X        underscore = ztrdup(getdata(lastnode(c->args)));
  1166. X        untokenize(underscore);
  1167. X    }
  1168. X    incmdpos = 1;
  1169. X    return c;
  1170. X}
  1171. X
  1172. X/*
  1173. X * cond    : cond_1 { SEPER } [ DBAR { SEPER } cond ]
  1174. X */
  1175. XCond par_cond() /**/
  1176. X{
  1177. XCond c,c2;
  1178. X
  1179. X    c = par_cond_1();
  1180. X    while (tok == SEPER) yylex();
  1181. X    if (tok == DBAR) {
  1182. X        yylex();
  1183. X        while (tok == SEPER) yylex();
  1184. X        c2 = make_cond();
  1185. X        c2->left = c;
  1186. X        c2->right = par_cond();
  1187. X        c2->type = COND_OR;
  1188. X        return c2;
  1189. X    }
  1190. X    return c;
  1191. X}
  1192. X
  1193. X/*
  1194. X * cond_1 : cond_2 { SEPER } [ DAMPER { SEPER } cond_1 ]
  1195. X */
  1196. XCond par_cond_1() /**/
  1197. X{
  1198. XCond c,c2;
  1199. X
  1200. X    c = par_cond_2();
  1201. X    while (tok == SEPER) yylex();
  1202. X    if (tok == DAMPER) {
  1203. X        yylex();
  1204. X        while (tok == SEPER) yylex();
  1205. X        c2 = make_cond();
  1206. X        c2->left = c;
  1207. X        c2->right = par_cond_1();
  1208. X        c2->type = COND_AND;
  1209. X        return c2;
  1210. X    }
  1211. X    return c;
  1212. X}
  1213. X
  1214. X/*
  1215. X * cond_2    : BANG cond_2
  1216. X                | INPAR { SEPER } cond_2 { SEPER } OUTPAR
  1217. X                | STRING STRING STRING
  1218. X                | STRING STRING
  1219. X                | STRING ( INANG | OUTANG ) STRING
  1220. X */
  1221. XCond par_cond_2() /**/
  1222. X{
  1223. XCond c,c2;
  1224. Xchar *s1,*s2,*s3;
  1225. Xint xtok;
  1226. X
  1227. X    if (tok == BANG) {
  1228. X        yylex();
  1229. X        c = par_cond_2();
  1230. X        c2 = make_cond();
  1231. X        c2->left = c;
  1232. X        c2->type = COND_NOT;
  1233. X        return c2;
  1234. X    }
  1235. X    if (tok == INPAR) {
  1236. X        yylex();
  1237. X        while (tok == SEPER) yylex();
  1238. X        c = par_cond();
  1239. X        while (tok == SEPER) yylex();
  1240. X        if (tok != OUTPAR) YYERROR;
  1241. X        yylex();
  1242. X        return c;
  1243. X    }
  1244. X    if (tok != STRING) YYERROR;
  1245. X    s1 = tokstr;
  1246. X    yylex();
  1247. X    xtok = tok;
  1248. X    if (tok == INANG || tok == OUTANG) {
  1249. X        yylex();
  1250. X        if (tok != STRING) YYERROR;
  1251. X        s3 = tokstr;
  1252. X        yylex();
  1253. X        c = make_cond();
  1254. X        c->left = s1;
  1255. X        c->right = s3;
  1256. X        c->type = (xtok == INANG) ? COND_STRLT : COND_STRGTR;
  1257. X        c->types[0] = c->types[1] = NT_STR;
  1258. X        return c;
  1259. X    }
  1260. X    if (tok != STRING) YYERROR;
  1261. X    s2 = tokstr;
  1262. X    yylex();
  1263. X    if (tok == STRING) {
  1264. X        s3 = tokstr;
  1265. X        yylex();
  1266. X        return par_cond_triple(s1,s2,s3);
  1267. X    } else
  1268. X        return par_cond_double(s1,s2);
  1269. X}
  1270. X
  1271. X/*
  1272. X * redir    : ( OUTANG | ... | TRINANG ) STRING
  1273. X */
  1274. Xvoid par_redir(l) /**/
  1275. XLklist l;
  1276. X{
  1277. Xchar *toks;
  1278. Xstruct redir *fn = allocnode(N_REDIR);
  1279. Xint mergerror = 0;
  1280. Xint oldcmdpos,oldnc;
  1281. X
  1282. X    oldcmdpos = incmdpos;
  1283. X    incmdpos = 0;
  1284. X    oldnc = nocorrect;
  1285. X    if (tok != INANG) nocorrect = 1;
  1286. X    fn->type = redirtab[tok-OUTANG];
  1287. X    fn->fd1 = tokfd;
  1288. X    yylex();
  1289. X    if (tok != STRING && tok != ENVSTRING) YYERRORV;
  1290. X    toks = tokstr;
  1291. X    incmdpos = oldcmdpos;
  1292. X    nocorrect = oldnc;
  1293. X    yylex();
  1294. X
  1295. X/* assign default fd */
  1296. X
  1297. X    if (fn->fd1 == -1)
  1298. X        fn->fd1 = IS_READFD(fn->type) ? 0 : 1;
  1299. X
  1300. X/* > >(...) or < <(...) */
  1301. X
  1302. X    if ((*toks == Inang || *toks == Outang) && toks[1] == Inpar) {
  1303. X        if ((fn->type & ~1) == WRITE) fn->type = OUTPIPE;
  1304. X        else if (fn->type == READ) fn->type = INPIPE;
  1305. X        else YYERRORV;
  1306. X        fn->name = toks;
  1307. X
  1308. X/* <<[-] name */
  1309. X
  1310. X    } else if (fn->type == HEREDOC || fn->type == HEREDOCDASH) {
  1311. X        char tbuf[256], *tlin;
  1312. X        int tsiz = 0, l;
  1313. X        /* Save the rest of the current line for later tokenization */
  1314. X        if (!isnewlin) {
  1315. X            while (hgets(tbuf, 256) != NULL) {
  1316. X                l = strlen(tbuf);
  1317. X                if (tsiz == 0) {
  1318. X                    tlin = ztrdup(tbuf); /* Test for failure? */
  1319. X                    tsiz = l;
  1320. X                } else {
  1321. X                    tlin = realloc(tlin,tsiz+l+1); /* Test for failure? */
  1322. X                    strcpy(&tlin[tsiz], tbuf);
  1323. X                    tsiz += l;
  1324. X                }
  1325. X                if (tbuf[l-1] == '\n') break;
  1326. X            }
  1327. X        }
  1328. X        /* Now grab the document */
  1329. X        fn->name = gethere(toks,fn->type);
  1330. X        fn->type = HERESTR;
  1331. X        /* Put back the saved line to resume tokenizing */
  1332. X        if (tsiz > 0) {
  1333. X            hungets(tlin);
  1334. X            free(tlin);
  1335. X        }
  1336. X
  1337. X/* >& name or >>& name */
  1338. X
  1339. X    } else if (IS_ERROR_REDIR(fn->type) && getfdstr(toks) == FD_WORD) {
  1340. X        mergerror = 1;
  1341. X        fn->name = toks;
  1342. X        fn->type = UN_ERROR_REDIR(fn->type);
  1343. X
  1344. X/* >>& and >>&! are only valid with a name after them */
  1345. X
  1346. X    } else if (fn->type == ERRAPP || fn->type == ERRAPPNOW) {
  1347. X        YYERRORV;
  1348. X
  1349. X/* >& # */
  1350. X
  1351. X    } else if (fn->type == MERGE || fn->type == MERGEOUT) {
  1352. X        fn->fd2 = getfdstr(toks);
  1353. X        if (fn->fd2 == FD_CLOSE) fn->type = CLOSE;
  1354. X        else if (fn->fd2 == FD_WORD) fn->fd2 = (fn->type==MERGEOUT) ? 1 : 0;
  1355. X    } else
  1356. X        fn->name = toks;
  1357. X    addnode(l,fn);
  1358. X    if (mergerror)
  1359. X        {
  1360. X        struct redir *fe = allocnode(N_REDIR);
  1361. X
  1362. X        fe->fd1 = 2;
  1363. X        fe->fd2 = fn->fd1;
  1364. X        fe->type = MERGEOUT;
  1365. X        addnode(l,fe);
  1366. X        }
  1367. X}
  1368. X
  1369. X/*
  1370. X * wordlist    : { STRING }
  1371. X */
  1372. XLklist par_wordlist() /**/
  1373. X{
  1374. XLklist l;
  1375. X
  1376. X    l = newlist();
  1377. X    while (tok == STRING) {
  1378. X        addnode(l,tokstr);
  1379. X        yylex();
  1380. X    }
  1381. X    return l;
  1382. X}
  1383. X
  1384. X/*
  1385. X * nl_wordlist    : { STRING | SEPER }
  1386. X */
  1387. XLklist par_nl_wordlist() /**/
  1388. X{
  1389. XLklist l;
  1390. X
  1391. X    l = newlist();
  1392. X    while (tok == STRING || tok == SEPER) {
  1393. X        if (tok != SEPER)
  1394. X            addnode(l,tokstr);
  1395. X        yylex();
  1396. X    }
  1397. X    return l;
  1398. X}
  1399. X
  1400. X/* get fd associated with str */
  1401. X
  1402. Xint getfdstr(s) /**/
  1403. Xchar *s;
  1404. X{
  1405. X    if (s[1]) return FD_WORD;
  1406. X    if (idigit(*s)) return *s-'0';
  1407. X    if (*s == 'p') return FD_COPROC;
  1408. X    if (*s == '-') return FD_CLOSE;
  1409. X    return FD_WORD;
  1410. X}
  1411. X
  1412. XCond par_cond_double(a,b) /**/
  1413. Xchar *a;char *b;
  1414. X{
  1415. XCond n = make_cond();
  1416. X
  1417. X    if (a[0] != '-' || !a[1] || a[2])
  1418. X        {
  1419. X        zerr("parse error: condition expected: %s",a,0);
  1420. X        return NULL;
  1421. X        }
  1422. X    n->left = b;
  1423. X    n->type = a[1];
  1424. X    n->types[0] = n->types[1] = NT_STR;
  1425. X    return n;
  1426. X}
  1427. X
  1428. XCond par_cond_triple(a,b,c) /**/
  1429. Xchar *a;char *b;char *c;
  1430. X{
  1431. XCond n = make_cond();
  1432. Xstatic char *condstrs[] = {
  1433. X    "nt","ot","ef","eq","ne","lt","gt","le","ge",NULL
  1434. X    };
  1435. Xint t0;
  1436. X
  1437. X    if ((b[0] == Equals || b[0] == '=') && !b[1])
  1438. X        n->type = COND_STREQ;
  1439. X    else if (b[0] == '!' && b[1] == '=' && !b[2])
  1440. X        n->type = COND_STRNEQ;
  1441. X    else if (b[0] == '-')
  1442. X        {
  1443. X        for (t0 = 0; condstrs[t0]; t0++)
  1444. X            if (!strcmp(condstrs[t0],b+1))
  1445. X                break;
  1446. X        if (condstrs[t0])
  1447. X            n->type = t0+COND_NT;
  1448. X        else
  1449. X            zerr("unrecognized condition: %s",b,0);
  1450. X        }
  1451. X    else
  1452. X        zerr("condition expected: %s",b,0);
  1453. X    n->left = a;
  1454. X    n->right = c;
  1455. X    n->types[0] = n->types[1] = NT_STR;
  1456. X    return n;
  1457. X}
  1458. X
  1459. Xvoid yyerror() /**/
  1460. X{
  1461. Xint t0;
  1462. X
  1463. X    for (t0 = 0; t0 != 20; t0++)
  1464. X        if (!yytext[t0] || yytext[t0] == '\n' || yytext[t0] == HISTSPACE)
  1465. X            break;
  1466. X    if (t0 == 20)
  1467. X        zerr("parse error near `%l...'",yytext,20);
  1468. X    else if (t0)
  1469. X        zerr("parse error near `%l'",yytext,t0);
  1470. X    else
  1471. X        zerr("parse error",NULL,0);
  1472. X}
  1473. X
  1474. SHAR_EOF
  1475. chmod 0644 zsh2.2/src/parse.c ||
  1476. echo 'restore of zsh2.2/src/parse.c failed'
  1477. Wc_c="`wc -c < 'zsh2.2/src/parse.c'`"
  1478. test 18760 -eq "$Wc_c" ||
  1479.     echo 'zsh2.2/src/parse.c: original size 18760, current size' "$Wc_c"
  1480. rm -f _shar_wnt_.tmp
  1481. fi
  1482. # ============= zsh2.2/src/zle_utils.pro ==============
  1483. if test -f 'zsh2.2/src/zle_utils.pro' -a X"$1" != X"-c"; then
  1484.     echo 'x - skipping zsh2.2/src/zle_utils.pro (File already exists)'
  1485.     rm -f _shar_wnt_.tmp
  1486. else
  1487. > _shar_wnt_.tmp
  1488. echo 'x - extracting zsh2.2/src/zle_utils.pro (Text)'
  1489. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_utils.pro' &&
  1490. Xvoid sizeline DCLPROTO((int sz));
  1491. Xvoid spaceinline DCLPROTO((int ct));
  1492. Xvoid backkill DCLPROTO((int ct,int dir));
  1493. Xvoid forekill DCLPROTO((int ct,int dir));
  1494. Xvoid cut DCLPROTO((int i,int ct,int dir));
  1495. Xvoid backdel DCLPROTO((int ct));
  1496. Xvoid foredel DCLPROTO((int ct));
  1497. Xvoid setline DCLPROTO((char *s));
  1498. Xvoid sethistline DCLPROTO((unsigned char *s));
  1499. Xint findbol DCLPROTO((void));
  1500. Xint findeol DCLPROTO((void));
  1501. Xvoid findline DCLPROTO((int *a,int *b));
  1502. Xvoid initundo DCLPROTO((void));
  1503. Xvoid addundo DCLPROTO((void));
  1504. Xvoid freeundo DCLPROTO((void));
  1505. Xint hstrncmp DCLPROTO((char *s,char *t,int len));
  1506. Xint hstrcmp DCLPROTO((char *s,char *t));
  1507. Xchar *hstrnstr DCLPROTO((char *s,char *t,int len));
  1508. SHAR_EOF
  1509. chmod 0644 zsh2.2/src/zle_utils.pro ||
  1510. echo 'restore of zsh2.2/src/zle_utils.pro failed'
  1511. Wc_c="`wc -c < 'zsh2.2/src/zle_utils.pro'`"
  1512. test 684 -eq "$Wc_c" ||
  1513.     echo 'zsh2.2/src/zle_utils.pro: original size 684, current size' "$Wc_c"
  1514. rm -f _shar_wnt_.tmp
  1515. fi
  1516. # ============= zsh2.2/src/signals.h.sample ==============
  1517. if test -f 'zsh2.2/src/signals.h.sample' -a X"$1" != X"-c"; then
  1518.     echo 'x - skipping zsh2.2/src/signals.h.sample (File already exists)'
  1519.     rm -f _shar_wnt_.tmp
  1520. else
  1521. > _shar_wnt_.tmp
  1522. echo 'x - extracting zsh2.2/src/signals.h.sample (Text)'
  1523. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/signals.h.sample' &&
  1524. XYour signals.h file should look something like this.  If it doesn't,
  1525. Xperhaps your csh or ed is different.
  1526. X
  1527. X/* this file is created automatically by buildzsh */
  1528. X/* if all this is wrong, blame csh ;-) */
  1529. X
  1530. X#define SIGCOUNT       31
  1531. X
  1532. X#ifdef GLOBALS
  1533. X
  1534. Xchar *sigmsg[SIGCOUNT+2] = {
  1535. X    "done",
  1536. X    "hangup",
  1537. X    "interrupt",
  1538. X    "quit",
  1539. X    "illegal instruction",
  1540. X    "trace trap",
  1541. X    "abort",
  1542. X    "EMT instruction",
  1543. X    "floating point exception",
  1544. X    "killed",
  1545. X    "bus error",
  1546. X    "segmentation fault",
  1547. X    "bad system call",
  1548. X    "broken pipe",
  1549. X    "SIGALRM",
  1550. X    "terminated",
  1551. X    "SIGURG",
  1552. X#ifdef USE_SUSPENDED
  1553. X    "suspended (signal)",
  1554. X#else
  1555. X    "stopped (signal)",
  1556. X#endif
  1557. X#ifdef USE_SUSPENDED
  1558. X    "suspended",
  1559. X#else
  1560. X    "stopped",
  1561. X#endif
  1562. X    "continued",
  1563. X    "SIGCHLD",
  1564. X#ifdef USE_SUSPENDED
  1565. X    "suspended (tty input)",
  1566. X#else
  1567. X    "stopped (tty input)",
  1568. X#endif
  1569. X#ifdef USE_SUSPENDED
  1570. X    "suspended (tty output)",
  1571. X#else
  1572. X    "stopped (tty output)",
  1573. X#endif
  1574. X    "SIGIO",
  1575. X    "cpu limit exceeded",
  1576. X    "filesize limit exceeded",
  1577. X    "virtual time alarm",
  1578. X    "SIGPROF",
  1579. X    "SIGWINCH",
  1580. X    "SIGLOST",
  1581. X    "SIGUSR1",
  1582. X    "SIGUSR2",
  1583. X    NULL
  1584. X};
  1585. X
  1586. Xchar *sigs[SIGCOUNT+4] = {
  1587. X    "EXIT",
  1588. X    "HUP",
  1589. X    "INT",
  1590. X    "QUIT",
  1591. X    "ILL",
  1592. X    "TRAP",
  1593. X    "ABRT",
  1594. X    "EMT",
  1595. X    "FPE",
  1596. X    "KILL",
  1597. X    "BUS",
  1598. X    "SEGV",
  1599. X    "SYS",
  1600. X    "PIPE",
  1601. X    "ALRM",
  1602. X    "TERM",
  1603. X    "URG",
  1604. X    "STOP",
  1605. X    "TSTP",
  1606. X    "CONT",
  1607. X    "CHLD",
  1608. X    "TTIN",
  1609. X    "TTOU",
  1610. X    "IO",
  1611. X    "XCPU",
  1612. X    "XFSZ",
  1613. X    "VTALRM",
  1614. X    "PROF",
  1615. X    "WINCH",
  1616. X    "LOST",
  1617. X    "USR1",
  1618. X    "USR2",
  1619. X    "ERR",
  1620. X    "DEBUG",
  1621. X    NULL
  1622. X};
  1623. X
  1624. X#else
  1625. X
  1626. Xextern char *sigs[SIGCOUNT+4],*sigmsg[SIGCOUNT+2];
  1627. X
  1628. X#endif
  1629. SHAR_EOF
  1630. chmod 0644 zsh2.2/src/signals.h.sample ||
  1631. echo 'restore of zsh2.2/src/signals.h.sample failed'
  1632. Wc_c="`wc -c < 'zsh2.2/src/signals.h.sample'`"
  1633. test 1429 -eq "$Wc_c" ||
  1634.     echo 'zsh2.2/src/signals.h.sample: original size 1429, current size' "$Wc_c"
  1635. rm -f _shar_wnt_.tmp
  1636. fi
  1637. # ============= zsh2.2/src/zle_move.c ==============
  1638. if test -f 'zsh2.2/src/zle_move.c' -a X"$1" != X"-c"; then
  1639.     echo 'x - skipping zsh2.2/src/zle_move.c (File already exists)'
  1640.     rm -f _shar_wnt_.tmp
  1641. else
  1642. > _shar_wnt_.tmp
  1643. echo 'x - extracting zsh2.2/src/zle_move.c (Text)'
  1644. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_move.c' &&
  1645. X/*
  1646. X *
  1647. X * zle_move.c - editor movement
  1648. X *
  1649. X * This file is part of zsh, the Z shell.
  1650. X *
  1651. X * This software is Copyright 1992 by Paul Falstad
  1652. X *
  1653. X * Permission is hereby granted to copy, reproduce, redistribute or otherwise
  1654. X * use this software as long as: there is no monetary profit gained
  1655. X * specifically from the use or reproduction of this software, it is not
  1656. X * sold, rented, traded or otherwise marketed, and this copyright notice is
  1657. X * included prominently in any copy made. 
  1658. X *
  1659. X * The author make no claims as to the fitness or correctness of this software
  1660. X * for any use whatsoever, and it is provided as is. Any use of this software
  1661. X * is at the user's own risk. 
  1662. X *
  1663. X */
  1664. X
  1665. X#define ZLE
  1666. X#include "zsh.h"
  1667. X
  1668. Xvoid beginningofline() /**/
  1669. X{
  1670. X    if (mult < 0) { mult = -mult; endofline(); return; }
  1671. X    while (mult--) {
  1672. X        if (cs == 0)
  1673. X            return;
  1674. X        if (line[cs-1] == '\n')
  1675. X            if (!--cs)
  1676. X                return;
  1677. X        while (cs && line[cs-1] != '\n') cs--;
  1678. X    }
  1679. X}
  1680. X
  1681. Xvoid endofline() /**/
  1682. X{
  1683. X    if (mult < 0) { mult = -mult; beginningofline(); return; }
  1684. X    while (mult--) {
  1685. X        if (cs >= ll) {
  1686. X            cs = ll;
  1687. X            return;
  1688. X        }
  1689. X        if (line[cs] == '\n')
  1690. X            if (++cs == ll)
  1691. X                return;
  1692. X        while (cs != ll && line[cs] != '\n') cs++;
  1693. X    }
  1694. X}
  1695. X
  1696. Xvoid beginningoflinehist() /**/
  1697. X{
  1698. X    if (mult < 0) { mult = -mult; endoflinehist(); return; }
  1699. X    while (mult) {
  1700. X        if (cs == 0)
  1701. X            break;
  1702. X        if (line[cs-1] == '\n')
  1703. X            if (!--cs)
  1704. X                break;
  1705. X        while (cs && line[cs-1] != '\n') cs--;
  1706. X        mult--;
  1707. X    }
  1708. X    if (mult) {
  1709. X        uphistory();
  1710. X        cs = 0;
  1711. X    }
  1712. X}
  1713. X
  1714. Xvoid endoflinehist() /**/
  1715. X{
  1716. X    if (mult < 0) { mult = -mult; beginningoflinehist(); return; }
  1717. X    while (mult) {
  1718. X        if (cs >= ll) {
  1719. X            cs = ll;
  1720. X            break;
  1721. X        }
  1722. X        if (line[cs] == '\n')
  1723. X            if (++cs == ll)
  1724. X                break;
  1725. X        while (cs != ll && line[cs] != '\n') cs++;
  1726. X        mult--;
  1727. X    }
  1728. X    if (mult)
  1729. X        downhistory();
  1730. X}
  1731. X
  1732. Xvoid forwardchar() /**/
  1733. X{
  1734. X    cs += mult;
  1735. X    if (cs > ll) cs = ll;
  1736. X    if (cs <  0) cs = 0;
  1737. X}
  1738. X
  1739. Xvoid backwardchar() /**/
  1740. X{
  1741. X    cs -= mult;
  1742. X    if (cs > ll) cs = ll;
  1743. X    if (cs <  0) cs = 0;
  1744. X}
  1745. X
  1746. Xvoid setmarkcommand() /**/
  1747. X{
  1748. X    mark = cs;
  1749. X}
  1750. X
  1751. Xvoid exchangepointandmark() /**/
  1752. X{
  1753. Xint x;
  1754. X
  1755. X    x = mark;
  1756. X    mark = cs;
  1757. X    cs = x;
  1758. X    if (cs > ll)
  1759. X        cs = ll;
  1760. X}
  1761. X
  1762. Xvoid vigotocolumn() /**/
  1763. X{
  1764. Xint x,y,ocs = cs;
  1765. X
  1766. X    if (mult > 0) mult--;
  1767. X    findline(&x,&y);
  1768. X    if (mult >= 0) cs = x+mult; else cs = y+mult;
  1769. X    if (cs < x || cs > y) {
  1770. X        feep();
  1771. X        cs = ocs;
  1772. X    }
  1773. X}
  1774. X
  1775. Xvoid vimatchbracket() /**/
  1776. X{
  1777. Xint ocs = cs,dir,ct;
  1778. Xchar oth,me;
  1779. X
  1780. Xotog:
  1781. X    if (cs == ll)
  1782. X        {
  1783. X        feep();
  1784. X        cs = ocs;
  1785. X        return;
  1786. X        }
  1787. X    switch(me = line[cs])
  1788. X        {
  1789. X        case '{': dir = 1; oth = '}'; break;
  1790. X        case '}': dir = -1; oth = '{'; break;
  1791. X        case '(': dir = 1; oth = ')'; break;
  1792. X        case ')': dir = -1; oth = '('; break;
  1793. X        case '[': dir = 1; oth = ']'; break;
  1794. X        case ']': dir = -1; oth = '['; break;
  1795. X        default: cs++; goto otog;
  1796. X        }
  1797. X    ct = 1;
  1798. X    while (cs >= 0 && cs < ll && ct)
  1799. X        {
  1800. X        cs += dir;
  1801. X        if (line[cs] == oth)
  1802. X            ct--;
  1803. X        else if (line[cs] == me)
  1804. X            ct++;
  1805. X        }
  1806. X    if (cs < 0 || cs >= ll)
  1807. X        {
  1808. X        feep();
  1809. X        cs = ocs;
  1810. X        }
  1811. X}
  1812. X
  1813. Xvoid viforwardchar() /**/
  1814. X{
  1815. X    if (mult < 0) { mult = -mult; vibackwardchar(); return; }
  1816. X    while (mult--) {
  1817. X        cs++;
  1818. X        if (cs >= ll || line[cs] == '\n') {
  1819. X            cs--;
  1820. X            break;
  1821. X        }
  1822. X    }
  1823. X}
  1824. X
  1825. Xvoid vibackwardchar() /**/
  1826. X{
  1827. X    if (mult < 0) { mult = -mult; viforwardchar(); return; }
  1828. X    while (mult--) {
  1829. X        cs--;
  1830. X        if (cs < 0 || line[cs] == '\n') {
  1831. X            cs++;
  1832. X            break;
  1833. X        }
  1834. X    }
  1835. X}
  1836. X
  1837. Xvoid viendofline() /**/
  1838. X{
  1839. X    cs = findeol();
  1840. X    if (!virangeflag && cs != 0 && line[cs-1] != '\n') cs--;
  1841. X}
  1842. X
  1843. Xvoid vibeginningofline() /**/
  1844. X{
  1845. X    cs = findbol();
  1846. X}
  1847. X
  1848. X
  1849. Xstatic int vfindchar,vfinddir,tailadd;
  1850. X
  1851. Xvoid vifindnextchar() /**/
  1852. X{
  1853. X    if (vfindchar = vigetkey())
  1854. X        {
  1855. X        vfinddir = 1;
  1856. X        tailadd = 0;
  1857. X        virepeatfind();
  1858. X        }
  1859. X}
  1860. X
  1861. Xvoid vifindprevchar() /**/
  1862. X{
  1863. X    if (vfindchar = vigetkey())
  1864. X        {
  1865. X        vfinddir = -1;
  1866. X        tailadd = 0;
  1867. X        virepeatfind();
  1868. X        }
  1869. X}
  1870. X
  1871. Xvoid vifindnextcharskip() /**/
  1872. X{
  1873. X    if (vfindchar = vigetkey())
  1874. X        {
  1875. X        vfinddir = 1;
  1876. X        tailadd = -1;
  1877. X        virepeatfind();
  1878. X        }
  1879. X}
  1880. X
  1881. Xvoid vifindprevcharskip() /**/
  1882. X{
  1883. X    if (vfindchar = vigetkey())
  1884. X        {
  1885. X        vfinddir = -1;
  1886. X        tailadd = 1;
  1887. X        virepeatfind();
  1888. X        }
  1889. X}
  1890. X
  1891. Xvoid virepeatfind() /**/
  1892. X{
  1893. Xint ocs = cs;
  1894. X
  1895. X    if (!vfinddir) { feep(); return; }
  1896. X    if (mult < 0) { mult = -mult; virevrepeatfind(); return; }
  1897. X    while (mult--)
  1898. X        {
  1899. X        do
  1900. X            cs += vfinddir;
  1901. X        while (cs >= 0 && cs < ll && line[cs] != vfindchar && line[cs] != '\n');
  1902. X        if (cs < 0 || cs >= ll || line[cs] == '\n')
  1903. X            {
  1904. X            feep();
  1905. X            cs = ocs;
  1906. X            return;
  1907. X            }
  1908. X        }
  1909. X    cs += tailadd;
  1910. X    if (vfinddir == 1 && virangeflag) cs++;
  1911. X}
  1912. X
  1913. Xvoid virevrepeatfind() /**/
  1914. X{
  1915. X    if (mult < 0) { mult = -mult; virepeatfind(); return; }
  1916. X    vfinddir = -vfinddir;
  1917. X    virepeatfind();
  1918. X    vfinddir = -vfinddir;
  1919. X}
  1920. X
  1921. Xvoid vifirstnonblank() /**/
  1922. X{
  1923. X    cs = findbol();
  1924. X    while (cs != ll && iblank(line[cs]))
  1925. X        cs++;
  1926. X}
  1927. X
  1928. Xvoid visetmark() /**/
  1929. X{
  1930. Xint ch;
  1931. X
  1932. X    ch = getkey(1);
  1933. X    if (ch < 'a' || ch > 'z') {
  1934. X        feep();
  1935. X        return;
  1936. X    }
  1937. X    ch -= 'a';
  1938. X    vimarkcs[ch] = cs;
  1939. X    vimarkline[ch] = histline;
  1940. X}
  1941. X
  1942. Xvoid vigotomark() /**/
  1943. X{
  1944. Xint ch;
  1945. X
  1946. X    ch = getkey(1);
  1947. X    if (ch == c) ch = 26;
  1948. X    else {
  1949. X        if (ch < 'a' || ch > 'z') {
  1950. X            feep();
  1951. X            return;
  1952. X        }
  1953. X        ch -= 'a';
  1954. X    }
  1955. X    if (!vimarkline[ch]) {
  1956. X        feep();
  1957. X        return;
  1958. X    }
  1959. X    if (curhist != vimarkline[ch]) {
  1960. X        mult = vimarkline[ch];
  1961. X        vifetchhistory();
  1962. X        if (curhist != vimarkline[ch]) return;
  1963. X    }
  1964. X    cs = vimarkcs[ch];
  1965. X    if (cs > ll) ch = ll;
  1966. X}
  1967. X
  1968. Xvoid vigotomarkline() /**/
  1969. X{
  1970. X    vigotomark();
  1971. X    cs = findbol();
  1972. X}
  1973. SHAR_EOF
  1974. chmod 0644 zsh2.2/src/zle_move.c ||
  1975. echo 'restore of zsh2.2/src/zle_move.c failed'
  1976. Wc_c="`wc -c < 'zsh2.2/src/zle_move.c'`"
  1977. test 5181 -eq "$Wc_c" ||
  1978.     echo 'zsh2.2/src/zle_move.c: original size 5181, current size' "$Wc_c"
  1979. rm -f _shar_wnt_.tmp
  1980. fi
  1981. # ============= zsh2.2/src/zle_misc.c ==============
  1982. if test -f 'zsh2.2/src/zle_misc.c' -a X"$1" != X"-c"; then
  1983.     echo 'x - skipping zsh2.2/src/zle_misc.c (File already exists)'
  1984.     rm -f _shar_wnt_.tmp
  1985. else
  1986. > _shar_wnt_.tmp
  1987. echo 'x - extracting zsh2.2/src/zle_misc.c (Text)'
  1988. sed 's/^X//' << 'SHAR_EOF' > 'zsh2.2/src/zle_misc.c' &&
  1989. X/*
  1990. X *
  1991. X * zle_misc.c - miscellaneous editor routines
  1992. X *
  1993. X * This file is part of zsh, the Z shell.
  1994. X *
  1995. X * This software is Copyright 1992 by Paul Falstad
  1996. SHAR_EOF
  1997. true || echo 'restore of zsh2.2/src/zle_misc.c failed'
  1998. fi
  1999. echo 'End of zsh2.2 part 16'
  2000. echo 'File zsh2.2/src/zle_misc.c is continued in part 17'
  2001. echo 17 > _shar_seq_.tmp
  2002. exit 0
  2003.  
  2004. exit 0 # Just in case...
  2005.